.TITLE PARTY .IDENT /10.03/ ; ; Copyright (c) 1995-1999 by Mentec, Inc., U.S.A. ; All rights reserved ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED ; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE. ; ; D. N. CUTLER 14-FEB-74 ; ; MODIFIED FOR RSX-11M-PLUS V2.1 BY: ; ; C. B. PUTNAM ; J. R. KAUFFMAN ; B. S. MCCARTHY ; ; MODIFIED FOR RSX-11M-PLUS V3.0 BY: ; ; J. W. BERZLE ; J. R. KAUFFMAN ; J. M. LAWLER ; C. B. PUTNAM ; ; MODIFIED FOR RSX-11M-PLUS V4.4 BY ; ; B. S. MCCARTHY 28-FEB-91 10.00 ; ; BM432 -- ENHANCE COMMENTS IN PARITY CODE ; ; D. CARROLL 24-JULY-1992 10.01 ; ; DC140 -- CORRECT PROCESSING OF USER MODE ERRORS ON ; NON-CACHE MACHINES (GIVE PRIORITY TO FATAL ; MEMORY ERRORS). ; ; D. CARROLL 14-DEC-1992 10.02 ; ; DC141 -- DON'T DISABLE NXM TRAPS ON KDJ11 CPUs WHEN ; THE INTENT IS TO DISABLE UB TRAPS. ; ; Modified for RSX-11M-PLUS V4.6 by: ; ; D. Carroll 18-Oct-1995 10.03 ; DC404 - Include PSECT definition to allow ICB pool to be ; fully extended during sysgen ; ; ; MEMORY PARITY INTERRUPT HANDLING ; ; MACRO LIBRARY CALLS ; .IF DF P$$RTY .MCALL ABODF$, EPKDF$, HWDDF$, PCBDF$, TCBDF$, BGCK$A ABODF$ ; DEFINE TASK ABORT CODES EPKDF$ ; DEFINE ERROR PACKET OFFSETS HWDDF$ ; DEFINE HARDWARE REGISTERS PCBDF$ ; DEFINE PARTITION CONTROL BLOCK OFFSETS TCBDF$ ; DEFINE TASK CONTROL BLOCK OFFSETS ; ; PARITY VECTOR ; .ASECT .=114 .WORD $PARER ; POINT TO ENTRY POINT .WORD PR7 ; AT PR7 .PSECT .PAGE .IIF DF,K$$DAS&I$$CBP, .PSECT EXEC1 ;DC404 ;DC404 ;+ ; **-PARER-MEMORY PARITY ERROR INTERRUPT ; ; THIS ROUTINE IS ENTERED AS THE RESULT OF A MEMORY PARITY ERROR INTERRUPT. IF ; THE ERROR OCCURED IN THE EXECUTIVE OR WHILE ON THE SYSTEM STACK, THEN A ; MESSAGE IS PRINTED ON THE CONSOLE TERMINAL AND THE SYSTEM IS HALTED. ; ELSE A SWITCH TO THE SYSTEM STACK IS EXECUTED AND THE TASK IN WHICH ; THE PARITY ERROR OCCURED IS LOCKED IN MEMORY. ;- .ENABL LSB ; FIRST HANDLE RECURSION RECURS: JMP 60$ ;;; JUMP TO HALT PROCESSOR $PARER::INC $PARLV ;;; INTERRUPT RECURSION? BNE RECURS ;;; IF NE YES ; IF THEY EXIST, WE SAVE THE MEMORY SYSTEM REGISTERS ; IN THE SAVE AREA STARTING AT $MSTAT .IF DF P$$D70 MOV R0,-(SP) ;;; SAVE R0 MOV R1,-(SP) ;;; SAVE R1 MOV #$MPCSR,R0 ;;; POINT TO PARITY CSR TABLE MOV #$MSTAT,R1 ;;; POINT TO PARITY CSR SAVE AREA MOV @(R0)+,(R1)+ ;;; SAVE LOW ADDRESS REGISTER MOV @(R0)+,(R1)+ ;;; SAVE HIGH ADDRESS REGISTER MOV #-1,(R1) ;;; ASSUME MEM PARITY ON NONCACHE MACHINE CMP (R0)+,#MPCSR-2 ;;; RUNNING ON CACHE MACHINE? BNE 2$ ;;; IF NE NO MOV @-(R0),(R1)+ ;;; SAVE MEMORY ERROR REGISTER TST (R0)+ ;;; POINT TO ADDRESS OF MEM CTRL REG MOV @(R0)+,(R1)+ ;;; SAVE MEMORY CONTROL REGISTER MOV #3,@-2(R0) ;;; TURN CACHE TRAPS OFF BIT #HF.KDJ,$HFMSK ;;; IS THIS A KDJ11 PROCESSOR? BEQ 1$ ;;; IF EQ, NO, BIT1 = DISABLE UB TRAPS MOV #1,@-2(R0) ;;; DISABLE ONLY CACHE TRAPS 1$: MOV @(R0)+,(R1)+ ;;; SAVE MAINTENANCE REGISTER MOV @(R0)+,(R1)+ ;;; SAVE CACHE HIT REGISTER 2$: MOV (SP)+,R1 ;;; RESTORE R1 MOV (SP)+,R0 ;;; RESTORE R0 .IFTF ; IF TRAP OCCURRED IN USER MODE, ALL ERRORS ; ARE RECOVERABLE BIT #CMODE,2(SP) ;;; PREVIOUS MODE USER? BNE 4$ ;;; IF NE YES .IFT ; TRAP WAS IN KERNEL MODE. IF THE ERROR WAS FATAL, ; WE CRASH. IF IT WAS A CACHE PARITY ERROR, WE CAN ; DISABLE THE CORRECT PART OF THE CACHE AND CONTINUE 3$: TST $STAT ;;; FATAL MEMORY ERROR? BGT 301$ ;;; IF GT NO JMP 20$ ;;; 301$: MOV R0,-(SP) ;;; SAVE REGISTERS MOV R1,-(SP) ;;; MOV #$ERTRK,R1 ;;; POINT TO ERROR TRACKING TABLE CALL 14$ ;;; EXECUTE CACHE ALGORITHM MOV (SP)+,R1 ;;; RESTORE REGISTERS MOV (SP)+,R0 ;;; RTI ;;; RETURN FROM TRAP .IFF 3$: BR 20$ ;;; FATAL MEMORY PARITY ERROR .IFTF ; AT THIS POINT, WE HAVE A RECOVERABLE ERROR, I.E. ONE ; WHICH DOESN'T IMPACT THE INTEGRITY OF THE SYSTEM 4$: DIRSV$ ;;; SAVE REGISTERS AND SET PRIORITY .IFT ; IF IT'S A CACHE ERROR, WE JUST LOG IT AND PROCEED. TST $STAT ; FATAL MEMORY ERROR BMI 401$ ; IF MI, YES, MAIN MEMORY ERROR CALL LOG ; LOG CACHE ERROR JMP 11$ ; GO ON ; FIND THE REGION WITH THE PARITY ERROR AND LOCK ; IT IN MEMORY. 401$: MOV @$MPCSR+2,R0 ; GET CONTENTS OF HIGH ERROR ADDRESS REG MOV @$MPCSR,R1 ; GET CONTENTS OF LOW ERROR ADDRESS REG ASHC #-6,R0 ; DOUBLE SHIFT R0 AND R1 RIGHT SIX BITS MOV #$PARHD,R0 ; GET ADDRESS OF PARTITION LIST HEAD 5$: MOV (R0),R0 ; GET NEXT MAIN PCB ADDRESS BEQ 65$ ; IF EQ END OF LIST CMP P.REL(R0),R1 ; DID ERROR OCCUR IN THIS REGION? BHI 65$ ; IF HI THERE IS NO PCB FOR REGION MOV P.REL(R0),R2 ; GET BASE ADDRESS OF PARTITION ADD P.SIZE(R0),R2 ; CALCULATE END OF PARTITION CMP R2,R1 ; DID ERROR OCCUR IN THIS REGION? BLOS 5$ ; IF LO NO 6$: MOV P.SUB(R0),R0 ; GET NEXT SUB PARTITION BEQ 65$ ; IF EQ END OF LIST CMP P.REL(R0),R1 ; DID ERROR OCCUR IN THIS REGION? BHI 65$ ; IF HI THERE IS NO PCB FOR REGION MOV P.REL(R0),R2 ; GET BASE ADDRESS OF PARTITION ADD P.SIZE(R0),R2 ; CALCULATE END OF PARTITION CMP R2,R1 ; DID ERROR OCCUR IN THIS REGION? BLOS 6$ ; IF LO NO BIS #PS.PER!PS.NSF!PS.CHK,P.STAT(R0) ;LOCK REGION BIC #PS.FXD,P.STAT(R0) ; BR 76$ ; SKIP NON-CACHE MACHINE CODE 65$: ; REFERENCE LABEL .IFTF ; ; LOCK ALL OF THE CURRENT TASK'S REGIONS IN MEMORY ; PS.FXD IS CLEARED IN THE TASK REGION PCB SO THAT ; THE TASK IS NO LONGER FIXED. THIS WILL ASSURE THAT ; WHEN THE TASK EXITS, IT WILL BE DETACHED FROM ITS REGIONS. ; MOV $TKTCB,R0 ; COPY TCB ADDRESS OF CURRENT TASK MOV T.PCB(R0),R1 ; GET TASK REGION PCB BIC #PS.FXD,P.STAT(R1) ; UNFIX THE TASK ADD #T.ATT,R0 ; POINT TO ATT LIST 7$: MOV (R0),R0 ; GET ADDRESS OF NEXT ATTACHMENT DESCRIPTOR BEQ 10$ ; IF EQ END OF LIST TSTB A.MPCT-A.TCBL(R0) ; TASK MAPPED? BEQ 7$ ; IF EQ NO MOV A.PCB-A.TCBL(R0),R1 ; GET PCB ADDRESS BIS #PS.PER!PS.NSF!PS.CHK,P.STAT(R1) ; LOCK REGION BIC #PS.FXD,P.STAT(R1) ; BR 7$ ; GO AGAIN .IFT ; IF THIS IS A UNIBUS PARITY ERROR, NOTIFY ALL MAPPED TASKS ; IF THIS IS A CPU PARITY ERROR, NOTIFY THE CURRENT TASK ; IN EITHER CASE, TASKS WHICH ARE FIXED BECOME UNFIXED. 76$: CMP $MPCSR+4,#MEMERR ; IS THIS A NON-CACHE MACHINE HANDLER BNE 10$ ; IF EQ, YES, DON'T PROCESS UBPE BIT #HF.KDJ,$HFMSK ; IS THIS A KDJ11 PROCESSOR? BNE 10$ ; YUP, THERE IS NO UBPE IN STATUS BIT #30000,$STAT ; UNIBUS PARITY ERROR? BEQ 10$ ; IF EQ NO MOV R0,-(SP) ; SAVE R0 CALL LOG ; LOG THE PARITY ERROR MOV (SP)+,R0 ; RESTORE R0 ADD #P.ATT,R0 ; POINT TO PARTITION'S ATT DESCR LIST 8$: MOV (R0),R0 ; POINT TO NEXT ATTACHMENT DESCRIPTOR BEQ 101$ ; IF EQ END OF LIST TSTB A.MPCT-A.PCBL(R0) ; TASK MAPPED? BEQ 8$ ; IF EQ NO MOV A.TCB-A.PCBL(R0),R5 ; GET TCB OF ATTACHED TASK MOV T.PCB(R5),R4 ; GET ADDRESS OF TASK REGION PCB BIC #PS.FXD,P.STAT(R4) ; UNFIX THE TASK MOV #AS.PEA,R4 ; GET CODE FOR PARITY ERROR AST TST T.ASTL(R5) ; AST ALREADY QUEUED? BEQ 9$ ; IF EQ NO MOV T.ASTL+2(R5),R1 ; CMPB R4,A.CBL+1(R1) ; PARITY ERROR AST QUEUED? BEQ 8$ ; IF EQ YES 9$: MOV R0,-(SP) ; SAVE R0 CALL DASTT ; DECLARE AN AST FOR THE ATTACHED TASK MOV (SP)+,R0 ; RESTORE R0 BCC 8$ ; IF CC AST SUCCESSFULLY DECLARED TST $STAT ; CACHE ERROR? BGT 8$ ; IF GT, YES BIT #T2.ABO,T.ST2(R5) ; ALREADY MARKED FOR ABORT? BNE 8$ ; IF NE YES MOV R0,-(SP) ; SAVE R0 MOV R5,R1 ; COPY TCB ADDRESS MOV #S.PRTY,R0 ; GET CODE FOR PARITY ERROR ABORT CALL $ABTSK ; ABORT THE TASK 901$: MOV (SP)+,R0 ; RESTORE R0 BR 8$ ; GO AGAIN .IFTF ; DECLARE AN AST FOR THE CURRENT TASK. IF PARITY ERROR ; AST IS NOT SPECIFIED, ABORT THE TASK. 10$: CALL LOG ; LOG THE PARITY ERROR MOV $TKTCB,R5 ; GET CURRENT TASK TCB ADDRESS MOV #AS.PEA,R4 ; GET CODE FOR PARITY ERROR AST CALL DASTT ; DECLARE AST BCC 11$ ; IF CC AST HAS BEEN DECLARED .IFT TST $STAT ; MAIN MEMORY ERROR? BGT 11$ ; IF GT, NOPE, CACHE ERROR, DON'T ABORT .IFTF MOV R5,R1 ; COPY TCB ADDRESS MOV #S.PRTY,R0 ; GET CODE FOR PARITY ERROR ABORT CALL $ABTSK ; ABORT CURRENT TASK 101$: MOV $FXRPT,R0 ; IS THE FIXER INSTALLED? BEQ 11$ ; IF EQ NO CALL $EXRQN ; REQUEST THE FIXER ; CLEAR ALL PARITY REGISTERS AND REENABLE PARITY ERRORS 11$: CALL $CLPAR ; RESET ALL PARITY CSR'S .IFT MOV #$ERTRK,R1 ; POINT TO ERROR TRACKING TABLE TST $STAT ; WAS IT ONLY A CACHE ERROR? BGT 14$ ; IF GT YES BR 16$ ; ; ; PDP-11/70 CACHE TRAP ; 12$: MOV $TTNS-4,-(R1) ;;; SAVE TIME OF LAST ERROR 13$: TST (R1)+ ;;; POINT TO NEXT GROUP 14$: MOVB (R1)+,R0 ;;; GET CACHE DISABLE BITS BEQ 16$ ;;; IF EQ END OF TABLE BITB (R1)+,$STAT ;;; ERROR IN THIS GROUP? BEQ 13$ ;;; IF EQ NO CMP (R1)+,$TTNS-4 ;;; OCCUR IN SAME MINUTE? BNE 12$ ;;; IF NE NO BISB R0,$MPCTL ;;; DISABLE THAT PART OF CACHE BR 14$ ;;; PROCESS NEXT GROUP 16$: MOVB $MPCTL,@$MPCSR+6 ;;; LOAD CACHE CONTROL REGISTER .ENDC ; AT THIS POINT EVERYTHING HAS BEEN CLEANED UP AND ; THE USER MAY INSERT CODE SPECIFIC TO HIS APPLICATION. ;******************************************************************** ; ; INSERT CODE HERE- IF PS[13:12] .NE. 0 ALL REGISTERS SAVED ; IF PS[13:12] .EQ. 0 R0,R1 ONLY SAVED ; ;******************************************************************** ; EXIT SYSTEM ; DEC $PARLV ; RESET RECURSION LEVEL RETURN ; EXIT FROM TRAP ; PARITY ERROR OCCURED WHILE IN EXEC CODE. THIS IS A ; FATAL SITUATION AND THE SYSTEM IS SHUT DOWN. THE USER ; MAY INSERT CODE SPECIFIC TO HIS APPLICATION AT THIS ; POINT. 20$: ;;; REF LABEL .IF DF M$$PRO CALL $DISAN ;;; DISABLE SANITY TIMERS/ALARMS .ENDC ; DF M$$PRO ;;;****************************************************************** ;;; ;;; INSERT CODE HERE-ALL REGISTERS HAVE NOT BEEN SAVED ;;; ;;;****************************************************************** MOV #60$,@#4 ;;; PLUG NONEX MEMORY VECTOR MOV R0,-(SP) ;;; SAVE R0 MOV #$EXMSG,R0 ;;; GET ADDRESS OF PARITY STOP MESSAGE 30$: MOVB (R0)+,TPS+2 ;;; OUTPUT NEXT BYTE BEQ 50$ ;;; IF EQ DONE 40$: TSTB TPS ;;; OUTPUT DONE? BPL 40$ ;;;IF PL NO BR 30$ ;;; GO AGAIN 50$: MOV (SP)+,R0 ;;; RESTORE R0 60$: BGCK$A BF.PAR,BE.FHW,HALT ;;; PARITY ERROR WHILE IN EXEC CODE BR 60$ ;;;IF CONTINUED HALT AGAIN .DSABL LSB .PAGE ;+ ; **-$CLPAR-CLEAR PARITY REGISTERS ; ; THIS ROUTINE CLEARS OUT ALL PARITY ERRORS IN THE MEMORY PARITY ERROR ; REGISTERS AND ENABLES PARITY ERROR NOTIFICATION. ; ; INPUTS: ; ; NONE. ; ; OUTPUTS: ; ; NONE. ; ; NOTE: IF THE SYMBOL M$$K11 IS DEFINED (11/70 TYPE ECC MEMORY), ; THIS ROUTINE WILL NOT PROPERLY HANDLE UNIBUS ECC MEMORY ; (SUCH AS MF11S-K) SINCE THE ROUTINE ASSUMES THAT ANY ; OTHER MEMORY ON THE SYSTEM MUST BE PARITY MEMORY AND ; THAT AN ATTEMPT TO SET THE SINGLE-BIT ECC ERROR BIT ON ; SUCH A MEMORY WILL FAIL. THIS ASSUMPTION IS USED TO ; DISTINGUISH MK11 ECC MEMORY FROM PARITY MEMORY. ;- $CLPAR::MOV #$PARTB+2,R0 ; POINT TO PARITY CSR VECTOR 10$: ; REF LABEL .IF DF M$$K11 TST (R0) ; EVEN WORD CSR PRESENT? BPL 20$ ; IF PL NO MOV #21,@(R0)+ ; SET ENABLE AND SINGLE-BIT ECC ERROR BIT #20,@-(R0) ; SINGLE-BIT ECC ERROR BIT SET (MK11)? BEQ 20$ ; IF EQ NO MOV #1,@(R0)+ ; SET ENABLE BIT AND CLR REST IN 1ST WORD BIC #100000,@(R0)+ ; CLEAR ERROR BIT IN SECOND WORD BR 30$ ; 20$: MOV #1,@(R0)+ ; ENABLE PARITY ERROR NOTIFICATION .ENDC MOV #1,@(R0)+ ; ENABLE PARITY (OR UNIBUS MEM ECC) NOTIF 30$: CMP R0,#$PARTB+2+<16.*2> ; DONE YET? BLO 10$ ; IF LO NO .IF DF P$$D70 MOV @$MPCSR+4,-(SP) ; CLEAR MEMORY SYSTEM ERROR REGISTER MOV (SP)+,@$MPCSR+4 ; .ENDC RETURN ; ;+ ; THE FORMAT OF ERROR LOGGING PACKETS IS AS FOLLOWS: ; ; +-----------------------------------------------+ ; | | ; \ FIXED ERROR LOGGING INFORMATION \ ; | | ; +-----------------------------------------------+ ; | CACHE REGISTER EXISTENCE MASK (SEE BELOW) | 0 ; +-----------------------------------------------+ ; | PARITY CSR EXISTENCE MASK (SEE BELOW) | 2 ; +-----------------------------------------------+ ; ; PARITY CSRS: ; ; ADDRESS BIT VALUE IN MASK AT 2 ; +-----------------------------------------------+ ; | 172100 000001 | 4 ; +-----------------------------------------------+ ; | 172102 000002 | 6 ; +-----------------------------------------------+ ; | 172104 000004 | 10 ; +-----------------------------------------------+ ; \ \ ; +-----------------------------------------------+ ; | 172134 040000 | 40 ; +-----------------------------------------------+ ; | 172136 100000 | 42 ; +-----------------------------------------------+ ; ; CACHE CSRS: ; ; +-----------------------------------------------+ ; | 177740 LOW ERROR ADDRESS 000001 | 44 ; +-----------------------------------------------+ ; | 177742 HIGH ERROR ADDRESS 000002 | 46 ; +-----------------------------------------------+ ; | 177744 CACHE ERROR REGISTER 000004 | 50 ; +-----------------------------------------------+ ; | 177746 CACHE CONTROL REGISTER 000010 | 52 ; +-----------------------------------------------+ ; | 177750 CACHE MAINTENANCE REGISTER 000020 | 54 ; +-----------------------------------------------+ ; | 177752 CACHE HIT/MISS REGISTER 000040 | 56 ; +-----------------------------------------------+ .PAGE ;+ ; LOG PARITY ERROR IN A TASK ; ; THE FOLLOWING MAY BE LOGGED: ; ; 16 WORDS OF MEMORY PARITY CSR'S ; 6 WORDS OF CACHE PARITY CSR'S ;- LOG: BIT #ES.LOG,$ERFLA ; ARE WE LOGGING ERRORS? BEQ 30$ ; IF EQ NO INC $ERRSQ ; COUNT THE ERROR MOV #E$CMEM+,R0 ; GET CODE FOR PARITY ERROR MOV #<24.*2>,R1 ; GET SIZE OF DATA SUBPACKET MOV #SM.HDR!SM.TSK!SM.DAT,R2 ; GET CONTROL MASK BITS CLR R3 ; NO BEGINNING ADDRESS FOR DATA MOV $TKTCB,R4 ; SET CURRENT TASK TCB ADDRESS CLR R5 ; INDICATE NO UCB ADDRESS CALL $CRPKT ; CREATE THE ERROR LOG PACKET BCS 30$ ; IF CS NO PACKET CMP (R1)+,(R1)+ ; SKIP OVER CACHE CSR AND PARITY CSR ; EXISTENCE MASKS ; FILL IN PARITY CSRS AND MASK MOV #$MEMR1,R2 ; POINT TO MEMORY PARITY CSR TABLE CLR -(SP) ; SET PROTOTYPE MASK 10$: MOV #-1,(R1)+ ; ASSUME REGISTER DOES NOT EXIST CMP #160000,(R2)+ ; REAL CSR ADDRESS ? BHI 15$ ; IF HI NO, LEAVE -1 THERE MOV @-2(R2),-2(R1) ; REPLACE -1 WITH REAL THING BIS $BTMSK-$MEMR1-2(R2),(SP) ; INDICATE CSR EXISTS 15$: CMP R2,#$MEMR1+<16.*2> ; DONE YET? BLO 10$ ; IF LO NO MOV (SP)+,-44+2(R1) ; FILL IN PARITY CSR EXISTENCE WORD .IF DF P$$D70 MOV #$MPCSR,R2 ; POINT TO CACHE PARITY CSR'S MOV #$MSTAT,R0 ; POINT TO SAVED CACHE PARITY CSRS CLR -(SP) ; SET PROTOTYPE MASK 20$: MOV #-1,(R1)+ ; ASSUME REGISTER DOES NOT EXIST CMP #160000,(R2)+ ; REAL CSR ADDRESS ? BHI 25$ ; IF HI NO, LEAVE -1 THERE MOV (R0),-2(R1) ; REPLACE -1 WITH REAL THING BIS $BTMSK-$MPCSR-2(R2),(SP) ; INDICATE CSR EXISTS 25$: TST (R0)+ ; POINT TO NEXT CSR VALUE CMP R2,#$MPCSR+<6*2>; DONE YET? BLO 20$ ; IF LO NO MOV (SP)+,-60(R1) ; FILL IN CACHE CSR EXISTENCE WORD .IFF ; DF P$$D70 CLR -44(R1) ; INDICATE NO CACHE CSRS EXIST .ENDC ; DF P$$D70 CALL $QUPKT ; QUEUE THE ERROR LOG PACKET 30$: RETURN ; .PAGE ;+ ; DASTT ; ; DECLARE A PARITY ERROR AST AND SET UP THE AST PARAMETERS ; ; INPUTS: ; ; R4=CODE INDICATING WHICH AST SHOULD BE DECLARED. ; R5=ADDRESS OF THE TCB OF THE TASK TO DECLARE THE AST FOR. ; ; OUTPUTS: ; ; C=1 IF THE TASK IS NOT SETUP FOR A PARITY ERROR AST. ; C=0 IF THE TASK IS SET UP FOR A PARITY ERROR AST. ; THE AST PARAMETERS ARE MOVED TO THE AST CONTROL BLOCK. ; R1=ADDRESS OF THE AST CONTROL BLOCK. ;- DASTT: CALL $DASTT ; DECLARE AN AST BCS 100$ ; IF CS AST HAS NOT BEEN SPECIFIED ADD #A.PRM,R1 ; POINT TO PARAMETER LIST IN AST BLOCK MOV -2(R1),(R1) ; MOVE NUMBER OF AST PARAMETERS ASL (R1)+ ; CALCULATE NUMBER OF BYTES ON STACK .IF DF M$$PRO MOVB $PROCN,(R1)+ ; GET PROCESSOR ID TSTB (R1)+ ; SKIP TO NEXT WORD .IFF CLR (R1)+ ; CLEAR PROCESSOR ID .ENDC MOV #$MPCSR,R0 ; POINT TO MEMORY STATUS REGISTERS 10$: MOV @(R0)+,(R1)+ ; LOW / HIGH ERR, MEM SYS ERR, CACHE CTRL CMP R0,#$MPCSR+<4.*2> ; DONE YET? BLO 10$ ; IF LO NO MOV #$PARTB+2,R0 ; POINT TO MEMORY PARITY CSR TABLE 20$: MOV @(R0)+,(R1)+ ; GET MEMORY PARITY CSR CONTENTS CMP R0,#$PARTB+<16.*2> ; DONE YET? BLO 20$ ; IF LO NO CLC ; INDICATE SUCCESS 100$: RETURN ; .ENDC ; DF P$$RTY .END